from __future__ import annotations

import builtins
import time
import types

# imports
import pytest
import requests
from codeflash.cli_cmds.console import logger
from codeflash.code_utils.version_check import check_for_newer_minor_version
from codeflash.version import __version__
from packaging import version


@pytest.fixture
def patch_version(monkeypatch):
    """Patch __version__ in codeflash.version for test isolation."""
    def _patch(ver):
        monkeypatch.setattr("codeflash.version.__version__", ver)
    return _patch

@pytest.fixture
def fake_logger(monkeypatch):
    """Capture logger.warning and logger.debug calls."""
    calls = {"warning": [], "debug": []}
    class FakeLogger:
        def warning(self, msg):
            calls["warning"].append(msg)
        def debug(self, msg):
            calls["debug"].append(msg)
    monkeypatch.setattr("codeflash.cli_cmds.console.logger", FakeLogger())
    return calls

@pytest.fixture
def patch_get_latest(monkeypatch):
    """Patch get_latest_version_from_pypi to return a controlled value."""
    def _patch(value):
        monkeypatch.setattr(__name__ + ".get_latest_version_from_pypi", lambda: value)
    return _patch

# --- BASIC TEST CASES ---






















#------------------------------------------------
from __future__ import annotations

import sys
import time

# imports
import pytest  # used for our unit tests
import requests
from codeflash.code_utils.version_check import check_for_newer_minor_version
from packaging import version


# --- Mock logger and __version__ for test isolation ---
class DummyLogger:
    def __init__(self):
        self.warned = []
        self.debugged = []
    def warning(self, msg):
        self.warned.append(msg)
    def debug(self, msg):
        self.debugged.append(msg)

# Use a dummy logger for tests
logger = DummyLogger()

# Patch __version__ for tests
__version__ = '1.2.3'

_version_cache = {"version": '0.0.0', "timestamp": float(0)}
_cache_duration = 3600  # 1 hour cache
from codeflash.code_utils.version_check import check_for_newer_minor_version


@pytest.fixture
def mock_requests(monkeypatch):
    """Fixture to mock requests.get for PyPI version checks."""
    class DummyResponse:
        def __init__(self, status_code, json_data):
            self.status_code = status_code
            self._json_data = json_data
        def json(self):
            return self._json_data
    def _mock_get(url, timeout=2):
        # Will be patched per test
        return DummyResponse(200, {"info": {"version": "1.2.3"}})
    monkeypatch.setattr(requests, "get", _mock_get)
    return _mock_get, DummyResponse

# --- Basic Test Cases ---

def test_no_newer_version_basic(mock_requests, monkeypatch):
    """Current version matches PyPI version: should not warn."""
    mock_requests[0].__defaults__ = (200, {"info": {"version": "1.2.3"}})
    check_for_newer_minor_version() # 624μs -> 7.47μs (8254% faster)

def test_newer_minor_version_available(mock_requests, monkeypatch):
    """Current version is lower minor: should warn."""
    mock_requests[0].__defaults__ = (200, {"info": {"version": "1.3.0"}})
    check_for_newer_minor_version() # 603μs -> 5.80μs (10308% faster)

def test_newer_major_version_available(mock_requests, monkeypatch):
    """Current version is lower major: should warn."""
    mock_requests[0].__defaults__ = (200, {"info": {"version": "2.0.0"}})
    check_for_newer_minor_version() # 601μs -> 5.59μs (10656% faster)

def test_newer_patch_version_available(mock_requests, monkeypatch):
    """Current version is lower patch: should warn (since > comparison)."""
    mock_requests[0].__defaults__ = (200, {"info": {"version": "1.2.4"}})
    check_for_newer_minor_version() # 598μs -> 5.65μs (10497% faster)

def test_lower_version_on_pypi(mock_requests, monkeypatch):
    """Current version is newer than PyPI: should not warn."""
    mock_requests[0].__defaults__ = (200, {"info": {"version": "1.2.2"}})
    check_for_newer_minor_version() # 595μs -> 5.49μs (10741% faster)

def test_equal_versions(mock_requests, monkeypatch):
    """Current version equals PyPI: should not warn."""
    mock_requests[0].__defaults__ = (200, {"info": {"version": "1.2.3"}})
    check_for_newer_minor_version() # 597μs -> 5.36μs (11050% faster)

# --- Edge Test Cases ---

def test_invalid_version_format_on_pypi(mock_requests, monkeypatch):
    """PyPI returns invalid version string: should not crash, should debug."""
    mock_requests[0].__defaults__ = (200, {"info": {"version": "not.a.version"}})
    check_for_newer_minor_version() # 591μs -> 5.44μs (10772% faster)

def test_invalid_current_version_format(monkeypatch, mock_requests):
    """Current version is invalid: should not crash, should debug."""
    monkeypatch.setattr(sys.modules[__name__], "__version__", 'not.a.version')
    mock_requests[0].__defaults__ = (200, {"info": {"version": "1.2.4"}})
    check_for_newer_minor_version() # 592μs -> 5.46μs (10743% faster)

def test_network_error(monkeypatch, mock_requests):
    """Network error when fetching PyPI version: should not warn, should debug."""
    def raise_request_exception(url, timeout=2):
        raise requests.RequestException("Network down")
    monkeypatch.setattr(requests, "get", raise_request_exception)
    check_for_newer_minor_version() # 590μs -> 7.53μs (7742% faster)

def test_non_200_status_code(monkeypatch, mock_requests):
    """PyPI returns non-200 status: should not warn, should debug."""
    class DummyResponse:
        def __init__(self):
            self.status_code = 404
        def json(self): return {"info": {"version": "1.2.4"}}
    monkeypatch.setattr(requests, "get", lambda url, timeout=2: DummyResponse())
    check_for_newer_minor_version() # 593μs -> 5.18μs (11356% faster)

def test_missing_version_key(monkeypatch, mock_requests):
    """PyPI response missing version key: should not warn, should debug."""
    class DummyResponse:
        def __init__(self):
            self.status_code = 200
        def json(self): return {"info": {}}
    monkeypatch.setattr(requests, "get", lambda url, timeout=2: DummyResponse())
    check_for_newer_minor_version() # 596μs -> 4.92μs (12021% faster)

def test_cache_usage(monkeypatch, mock_requests):
    """Should use cache if within duration and not call requests.get again."""
    # Set cache to a recent value
    _version_cache["version"] = "1.3.0"
    _version_cache["timestamp"] = time.time()
    # Patch requests.get to raise if called
    monkeypatch.setattr(requests, "get", lambda url, timeout=2: pytest.fail("Should not call requests.get"))
    check_for_newer_minor_version()

def test_cache_expiry(monkeypatch, mock_requests):
    """Should call requests.get if cache expired."""
    # Set cache to expired value
    _version_cache["version"] = "1.3.0"
    _version_cache["timestamp"] = time.time() - (_cache_duration + 10)
    called = []
    def dummy_get(url, timeout=2):
        called.append(True)
        class DummyResponse:
            status_code = 200
            def json(self): return {"info": {"version": "2.0.0"}}
        return DummyResponse()
    monkeypatch.setattr(requests, "get", dummy_get)
    check_for_newer_minor_version() # 594μs -> 15.5μs (3741% faster)


def test_large_number_of_versions(monkeypatch, mock_requests):
    """Test with a large number of version increments."""
    # Simulate PyPI returning a much newer version
    monkeypatch.setattr(sys.modules[__name__], "__version__", '1.0.0')
    mock_requests[0].__defaults__ = (200, {"info": {"version": "1.999.0"}})
    check_for_newer_minor_version() # 624μs -> 6.67μs (9262% faster)

def test_large_scale_cache(monkeypatch):
    """Simulate cache with many different version values (under 1000)."""
    # Fill cache with many versions, but only latest should be used
    for i in range(1, 1000):
        _version_cache["version"] = f"1.{i}.0"
        _version_cache["timestamp"] = time.time()
        monkeypatch.setattr(sys.modules[__name__], "__version__", f"1.{i-1}.0")
        logger.warned.clear()
        check_for_newer_minor_version() # 529ms -> 70.7ms (648% faster)


def test_large_major_jump(monkeypatch, mock_requests):
    """Test with a large major jump."""
    monkeypatch.setattr(sys.modules[__name__], "__version__", '1.2.3')
    mock_requests[0].__defaults__ = (200, {"info": {"version": "999.0.0"}})
    check_for_newer_minor_version() # 603μs -> 28.0μs (2056% faster)


#------------------------------------------------
from codeflash.code_utils.version_check import check_for_newer_minor_version

def test_check_for_newer_minor_version():
    check_for_newer_minor_version()